home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1994 November: Tool Chest / Dev.CD Nov 94.toast / Sample Code / Snippets / Interapplication Communication / FinderOpenSelection 1.0.1 / FinderOpenSel.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-07-15  |  29.1 KB  |  824 lines  |  [TEXT/MPS ]
  1. /* FinderOpenSel 1.1 */
  2. /* This sample shows how to use the Finder OpenSelection AppleEvent. */
  3. /* You can use this event to launch applications or files, or open Finder windows */
  4. /* Version 1.1 here also shows you how to launch an application remotely */
  5. /* Written  by C.K. Haun <TR> */
  6. /* Apple Developer Tech Support */
  7. /* April 1992, Cupertino, CA USA */
  8. /* Of course, Copyright 1991-1992, Apple Computer Inc. */
  9. #include <Types.h>
  10. #include <memory.h>
  11. #include <Packages.h>
  12. #include <Errors.h>
  13. #include <quickdraw.h>
  14. #include <fonts.h>
  15. #include <dialogs.h>
  16. #include <windows.h>
  17. #include <menus.h>
  18. #include <events.h>
  19. #include <OSEvents.h>
  20. #include <Desk.h>
  21. #include <diskinit.h>
  22. #include <OSUtils.h>
  23. #include <resources.h>
  24. #include <toolutils.h>
  25. #include <AppleEvents.h>
  26. #include <EPPC.h>
  27. #include <GestaltEqu.h>
  28. #include <PPCToolbox.h> 
  29. #include <Processes.h>
  30. #include <Balloons.h>
  31. #include <ALiases.h>
  32. #include <Processes.h>
  33. #include <StandardFile.h>
  34. #include <Folders.h>
  35. /* prototypes */
  36. void InitalizeApp(void);
  37. void DoDiskEvents(long dinfo);                              /* hi word is error code, lo word is drive number */
  38. void DrawMain(WindowPtr drawIt);
  39. Boolean DoSelected(long val);
  40. OSErr FindAProcess(OSType typeToFind, OSType creatorToFind, ProcessSerialNumberPtr processSN, ProcessInfoRecPtr infoRecToFill);
  41. OSErr OpenSelection(short which);
  42. void InitAEStuff(void);
  43. void DoHighLevel(EventRecord *AERecord);
  44. void DoDaCall(MenuHandle themenu, long theit);
  45. pascal OSErr AEOpenHandler(AppleEvent *messagein, AppleEvent *reply, long refIn);
  46. pascal OSErr AEOpenDocHandler(AppleEvent *messagein, AppleEvent *reply, long refIn);
  47. pascal OSErr AEPrintHandler(AppleEvent *messagein, AppleEvent *reply, long refIn);
  48. pascal OSErr AEQuitHandler(AppleEvent *messagein, AppleEvent *reply, long refIn);
  49. void SampleHelpDialog(void);
  50. OSErr GetPathAndName(Str255 fullPath, Str255 appName);
  51. OSErr BrowseFerMe(void);
  52. pascal Boolean FinderFilter(LocationNamePtr locationName, PortInfoPtr thePortInfo);
  53. ControlHandle SnatchHandle(DialogPtr thebox, short theGetItem);
  54. pascal Boolean idleProc(EventRecord *eventIn, long *sleep, RgnHandle *mouseRgn);
  55.  
  56. long trashDirID;
  57. short trashVRef;
  58. /* These are the new Dialog Manager calls described in Tech note #304 */
  59. /* ONLY used if System 7 or later, of course */
  60. pascal OSErr GetStdFilterProc(ModalFilterProcPtr *theProc) = 
  61. {
  62.     0x303C, 0x0203, 0xAA68
  63. };
  64.  
  65.  
  66.  
  67.  
  68. /* Indicates to the dialog manager which item is default.  Will then alias the return key */
  69. /* to this item, and also bold border it for you (yaaaaa!) */
  70. pascal OSErr SetDialogDefaultItem(DialogPtr theDialog, short newItem)
  71. = 
  72. {
  73.     0x303C, 0x0304, 0xAA68
  74. };
  75.  
  76.  
  77.  
  78.  
  79. /* Indicates which item should be aliased to escape or Command - . */
  80. pascal OSErr SetDialogCancelItem(DialogPtr theDialog, short newItem)
  81. = 
  82. {
  83.     0x303C, 0x0305, 0xAA68
  84. };
  85.  
  86.  
  87.  
  88.  
  89. /* Tells the dialog manager that there is an edit line in this dialog, and */
  90. /* it should track and change to an I-Beam cursor when over the edit line */
  91. pascal OSErr SetDialogTracksCursor(DialogPtr theDialog, Boolean tracks) = 
  92. {
  93.     0x303C, 0x0306, 0xAA68
  94. };
  95.  
  96.  
  97.  
  98.  
  99. /* one external */
  100. extern void _DataInit();                                    /* this is the C initialization code */
  101.  
  102. #define kWaitDialog 132
  103. #define kMBarID 128
  104. #define kAppleMenu 128
  105. #define kFileMenu 129
  106. #define kEditMenu 130
  107. #define kToolsMenu 131
  108. #define kResumeMask 1 /* bit of message field for resume vs. suspend */
  109. #define kSampHelp 129
  110. #define kAboutBox 128
  111. #define kHelpString 128
  112. #define kNewItem 1
  113. #define kOpenItem 2
  114. #define kCloseItem 3
  115. #define kSaveItem 4
  116. #define kSaveAsItem 5
  117. #define kFileBlank1 6
  118. #define kPageSetupItem 7
  119. #define kPrintItem 8
  120. #define kFileBlank2 9
  121. #define kQuitItem 10
  122. #define kBadSystem 130
  123. #define kOpenAppItem 1
  124. #define kOpenWindowItem 2
  125. #define kRemoteLaunchItem 3
  126. #define kTextType 'TEXT'
  127. #define kTextResID 128
  128. #define kMyWindowResID 128
  129. #define aeSelectionKeyword 'fsel'
  130. #define kAEOpenSelection 'sope'
  131. #define kFinderType 'FNDR'
  132. #define kSysCreator 'MACS'
  133. #define kPathDialog 131
  134. #define kEditLineItem 4
  135. #define kColon ':'
  136. enum  {
  137.     kGenStrings = 128, kPPCPrompt1 = 1, kPPCPrompt2
  138. };
  139.  
  140. struct AEinstalls {
  141.     AEEventClass theClass;
  142.     AEEventID theEvent;
  143.     EventHandlerProcPtr theProc;
  144. };
  145. typedef struct AEinstalls AEinstalls;
  146.  
  147. Handle gMymenu;                                             /* my menu bar handle */
  148. MenuHandle gAppleMenuHandle, gFileMenuHandle, gEditMenuHandle, gToolMenuHandle;
  149. Boolean gQuit, gInBackground;
  150. EventRecord gERecord;
  151. AEDesc gTheAddress;
  152. WindowPtr myWindow = 0;
  153. ProcessSerialNumber gOurSN;
  154. short gHelpItem;
  155. LocationNameRec theLoc;
  156. PortInfoRec theRec;
  157. PPCPortRec myPortName;
  158. LocationNameRec myLoc;
  159. AEDesc myAddressDesc;
  160. TargetID theID;
  161. #pragma segment Main
  162. main()
  163. {
  164.     WindowPtr twindow;
  165.     
  166.     UnloadSeg((Ptr)_DataInit);                              /* throw out setup code */
  167.     InitalizeApp();
  168.     UnloadSeg((Ptr)InitalizeApp);                           /* get rid of my initialization code */
  169.     
  170.     do {
  171.         WaitNextEvent(everyEvent, &gERecord, 5, nil);
  172.         switch (gERecord.what) {
  173.             
  174.             case nullEvent:
  175.                 
  176.                 /* no nul processing in this sample */
  177.                 break;
  178.             case updateEvt:
  179.                 DrawMain((WindowPtr)gERecord.message);      /* draw whatever window needs an update */
  180.                 break;
  181.             case mouseDown:
  182.                 
  183.                 /* first see where the hit was */
  184.                 
  185.                 switch (FindWindow(gERecord.where, &twindow)) {
  186.                     
  187.                     case inDesk:                            /* if they hit in desk, then the process manager */
  188.                         break;                              /* will switch us out, we don't need to do anything */
  189.                     case inMenuBar:
  190.                         DoSelected(MenuSelect(gERecord.where));
  191.                         break;
  192.                         
  193.                     case inSysWindow:
  194.                         /* pass to the system */
  195.                         SystemClick(&gERecord, twindow);
  196.                         break;
  197.                         
  198.                     case inContent:
  199.                         /* Handle content and control clicks here */
  200.                         break;
  201.                         
  202.                     case inDrag:
  203.                         if (twindow == FrontWindow())
  204.                             DragWindow(twindow, gERecord.where, &qd.screenBits.bounds);
  205.                         break;
  206.                         
  207.                     case inGrow:
  208.                         /* Call GrowWindow here if you have a grow box */
  209.                         break;
  210.                         
  211.                     case inGoAway:
  212.                         /* Click in Close box */
  213.                         break;
  214.                         
  215.                 }
  216.             case mouseUp:
  217.                 /* don't care */
  218.                 break;
  219.                 
  220.                 /* same action for key or auto key */
  221.                 
  222.             case keyDown:
  223.             case autoKey:
  224.                 if (gERecord.modifiers & cmdKey)
  225.                     DoSelected(MenuKey(gERecord.message & charCodeMask));
  226.                 break;
  227.                 
  228.             case keyUp:
  229.                 /* don't care */
  230.                 break;
  231.                 
  232.             case diskEvt:
  233.                 /* I don't do anything special for disk events, this just passes them */
  234.                 /* to a function that checks for an error on the mount */
  235.                 DoDiskEvents(gERecord.message);
  236.                 break;
  237.                 
  238.             case activateEvt:
  239.                 if (gERecord.modifiers & activeFlag)
  240.                     DrawMain((WindowPtr)gERecord.message);
  241.                 break;
  242.                 
  243.             case networkEvt:
  244.                 /* don't care */
  245.                 break;
  246.                 
  247.             case driverEvt:
  248.                 /* don't care */
  249.                 break;
  250.                 
  251.             case app4Evt:
  252.                 switch ((gERecord.message >> 24) & 0x0FF) {     /* high byte of message */
  253.                     case suspendResumeMessage:              /* suspend/resume is also an activate/deactivate */
  254.                         gInBackground = (gERecord.message & kResumeMask) == 0;
  255.                         break;
  256.                 }
  257.                 break;
  258.                 
  259.                 /* This dispatches high level events (AppleEvents, for example) */
  260.                 /* to our dispatch routine.  This is NEW in the event loop for */
  261.                 /* System 7 */
  262.                 
  263.             case kHighLevelEvent:
  264.                 DoHighLevel(&gERecord);
  265.                 break;
  266.                 
  267.             default:
  268.                 break;
  269.                 
  270.         }
  271.     }
  272.             while (gQuit != true);
  273.     
  274. }
  275.  
  276. /* DoDaCall opens the requested DA.  It's here as a seperate routine if you'd */
  277. /* like to perform some action or just know when a DA is opened in your */
  278. /* layer.  Can be handy to track memory problems when a DA is opened */
  279. /* with an Option-open */
  280. void DoDaCall(MenuHandle themenu, long theit)
  281. {
  282.     long qq;
  283.     char DAname[255];
  284.     GetItem(themenu, theit, &DAname);
  285.     qq = OpenDeskAcc(DAname);
  286. }
  287.  
  288. /* end DoDaCall */
  289.  
  290. /* DoDiskEvents just checks the error code from the disk mount, */
  291. /* and puts up the 'Format' dialog (through DIBadMount) if need be */
  292. /* You can do much more here if you care about what disks are */
  293. /* in the drive */
  294. void DoDiskEvents(long dinfo)                               /* hi word is error code, lo word is drive number */
  295. {
  296.     short hival, loval, tommy;
  297.     Point fredpoint =  {
  298.         40, 40
  299.     };
  300.     hival = HiWord(dinfo);
  301.     loval = LoWord(dinfo);
  302.     if (hival != noErr)                                     /* something happened */ {
  303.         tommy = DIBadMount(fredpoint, dinfo);
  304.     }
  305. }
  306.  
  307. /* draws my window.  Pretty simple */
  308. void DrawMain(WindowPtr drawIt)
  309. {
  310.     Handle theText;
  311.     BeginUpdate(drawIt);
  312.     SetPort(drawIt);
  313.     EraseRect(&drawIt->portRect);
  314.     theText = GetResource(kTextType, kTextResID);
  315.     if (theText) {
  316.         Rect textRect;
  317.         HLock(theText);
  318.         HUnlock(theText);
  319.         textRect = drawIt->portRect;
  320.         InsetRect(&textRect, 5, 5);
  321.         TextBox(*theText, GetHandleSize(theText), &textRect, 0);
  322.         ReleaseResource(theText);
  323.     }
  324.     EndUpdate(drawIt);
  325. }
  326.  
  327. /* my menu action taker.  It returns a Boolean which I usually ignore, but it */
  328. /* mught be handy someday */
  329. Boolean DoSelected(long val)
  330. {
  331.     short loval, hival;
  332.     Boolean returnVal = false;
  333.     loval = LoWord(val);
  334.     hival = HiWord(val);
  335.     
  336.     switch (hival) {                                        /* switch off the menu number selected */
  337.         
  338.         case kAppleMenu:                                    /* Apple menu */
  339.             if (loval != 1) {                               /* if this was not About, it's a DA */
  340.                 DoDaCall(gAppleMenuHandle, loval);
  341.             } else {
  342.                 Alert(kAboutBox, nil);                      /* do about box */
  343.             }
  344.             returnVal = true;
  345.             break;
  346.             
  347.         case kFileMenu:                                     /* File menu */
  348.             switch (loval) {
  349.                 
  350.                 case kQuitItem:
  351.                     gQuit = true;                           /* only  item */
  352.                     returnVal = true;
  353.                     break;
  354.                     
  355.                 default:
  356.                     break;
  357.             }
  358.             break;
  359.             
  360.         case kEditMenu:
  361.             /* edit menu junk */
  362.             /* don't care */
  363.             break;
  364.             
  365.         case kToolsMenu:
  366.             /* add all your test stuff here */
  367.             OpenSelection(loval);
  368.             break;
  369.             
  370.         case kHMHelpMenuID:                                 /* Defined in Balloons.h */
  371.             /* I only care about this item.  If anything else is returned here, I don't know what */
  372.             /* it is, so I leave it alone.  Remember, the Help Manager chapter says that */
  373.             /* Apple reserves the right to add and change things in the Help menu */
  374.             if (loval == gHelpItem)
  375.                 SampleHelpDialog();
  376.             break;
  377.             
  378.     }
  379.     HiliteMenu(0);
  380.     return(returnVal);
  381. }
  382.  
  383. /* InitAEStuff installs my appleevent handlers */
  384. void InitAEStuff(void)
  385. {
  386.     static AEinstalls HandlersToInstall[] =  {
  387.         {
  388.             kCoreEventClass, kAEOpenApplication, AEOpenHandler
  389.         },  {
  390.             kCoreEventClass, kAEOpenDocuments, AEOpenDocHandler
  391.         },  {
  392.             kCoreEventClass, kAEQuitApplication, AEQuitHandler
  393.         },  {
  394.             kCoreEventClass, kAEPrintDocuments, AEPrintHandler
  395.         }, 
  396.         /* The above are the four required AppleEvents. */
  397.         
  398.     };
  399.     
  400.     OSErr aevtErr = noErr;
  401.     long aLong = 0;
  402.     Boolean gHasAppleEvents = false;
  403.     
  404.     /* Check this machine for AppleEvents.  If they are not here (ie not 7.0)
  405.     *   then we exit */
  406.     
  407.     gHasAppleEvents = (Gestalt(gestaltAppleEventsAttr, &aLong) == noErr);
  408.     
  409.     /* The following series of calls installs all our AppleEvent Handlers.
  410.     *   These handlers are added to the application event handler list that 
  411.     *   the AppleEvent manager maintains.  So, whenever an AppleEvent happens
  412.     *   and we call AEProcessEvent, the AppleEvent manager will check our
  413.     *   list of handlers and dispatch to it if there is one.
  414.     */
  415.     
  416.     if (gHasAppleEvents) {
  417.         register qq;
  418.         for (qq = 0; qq < ((sizeof(HandlersToInstall) / sizeof(AEinstalls))); qq++) {
  419.             
  420.             aevtErr = AEInstallEventHandler(HandlersToInstall[qq].theClass, HandlersToInstall[qq].theEvent,
  421.                                             HandlersToInstall[qq].theProc, 0, false);
  422.             if (aevtErr) {
  423.                 ExitToShell();                              /* just fail, baby */
  424.             }
  425.         }
  426.     } else {
  427.         ExitToShell();
  428.     }
  429. }
  430.  
  431. /* end InitAEStuff */
  432. /* I'm not doing error handling in this sample for clarities sake, you should. Hah, */
  433. /* easy for me to say, huh? */
  434. void DoHighLevel(EventRecord *AERecord)
  435. {
  436.     
  437.     AEProcessAppleEvent(AERecord);
  438.     
  439. }
  440.  
  441. /* end DoHighLevel */
  442.  
  443. /* This is the standard Open Application event.  */
  444. pascal OSErr AEOpenHandler(AppleEvent *messagein, AppleEvent *reply, long refIn)
  445. {
  446. #pragma unused (messagein,reply,refIn)
  447.     /* we of course don't do anything here in this simple app */
  448.     /* except open our window */
  449.     
  450.     myWindow = GetNewWindow(kMyWindowResID, nil, (WindowPtr)-1);
  451.     return(noErr);
  452. }
  453.  
  454. /* end AEOpenHandler */
  455.  
  456. /* Open Doc, opens our documents.  Remember, this can happen at application start AND */
  457. /* anytime else.  If your app is up and running and the user goes to the desktop, hilites one */
  458. /* of your files, and double-clicks or selects Open from the finder File menu this event */
  459. /* handler will get called. Which means you don't do any initialization of globals here, or */
  460. /* anything else except open then doc.  */
  461. /* SO-- Do NOT assume that you are at app start time in this */
  462. /* routine, or bad things will surely happen to you. */
  463.  
  464. pascal OSErr AEOpenDocHandler(AppleEvent *messagein, AppleEvent *reply, long refIn)
  465. {
  466. #pragma unused (messagein,refIn,reply)
  467.     /* we of course don't do anything here */
  468.     
  469.     return(errAEEventNotHandled);                           /* we have no docs, so no odoc events should come to us */
  470. }
  471.  
  472. pascal OSErr AEPrintHandler(AppleEvent *messagein, AppleEvent *reply, long refIn)
  473. {                                                           /* no printing handler in yet, so we'll ignore this */
  474.     /* the operation is functionally identical to the ODOC event, with the additon */
  475.     /* of calling your print routine.  */
  476. #pragma unused (messagein,refIn,reply)
  477.     
  478.     /* we of course don't do anything here */
  479.     return(errAEEventNotHandled);                           /* we have no docs, so no pdoc events should come to us */
  480. }
  481.  
  482. /* Standard Quit event handler, to handle a Quit event from the Finder, for example.  */
  483. /* ••••• DO NOT CALL EXITTOSHELL HERE ••••• or you will never have a happy life.  */
  484. pascal OSErr AEQuitHandler(AppleEvent *messagein, AppleEvent *reply, long refIn)
  485. {
  486. #pragma unused (messagein,refIn,reply)
  487.     
  488.     /* prepQuit sets the Stop flag for us.  It does _NOT_ quit, you */
  489.     /* should NEVER quit from an AppleEvent handler.  Calling */
  490.     /* ExitToShell here would blow things up */
  491.     gQuit = true;
  492.     return(noErr);
  493. }
  494.  
  495. /* This is my sample help dialog.  Does not do anything, expand as you need */
  496. void SampleHelpDialog(void)
  497. {
  498.     DialogPtr tdial = GetNewDialog(kSampHelp, nil, (WindowPtr)-1);
  499.     short itemhit = 0;
  500.     while (itemhit != 1) {
  501.         ModalDialog((ModalFilterProcPtr)nil, &itemhit);
  502.     }
  503.     DisposDialog(tdial);
  504. }
  505.  
  506. /* OpenSelection perpares and sends the Finder OpenSelection event */
  507. /* Three choices currently.  If which is 1, then we do an OpenSelection on the file itself. */
  508. /* if which is 2, then we tell the finder to open the directory window containing the file  */
  509. /* if it's 3, then we ask for a remote name and launch remotely */
  510.  
  511. OSErr OpenSelection(short which)
  512. {
  513.     AppleEvent aeEvent, aeReply;
  514.     AEDesc aeDirDesc, listElem;
  515.     OSErr interactErr = noErr;
  516.     FSSpec dirSpec, procSpec;
  517.     AEDesc fileList;
  518.     StandardFileReply myReply;
  519.     OSErr myErr;
  520.     ProcessSerialNumber process;
  521.     AliasHandle DirAlias, FileAlias;
  522.     FSSpecPtr theFileToOpen = nil;
  523.     ProcessInfoRec infoRec;
  524.     Str31 processName;
  525.     Str255 fullPath;
  526.     Str255 appName;
  527.     
  528.     if (which != kRemoteLaunchItem)
  529.         StandardGetFile(nil, -1, nil, &myReply);
  530.     else
  531.         myReply.sfGood = true;                              /* set this since I want to be silent this time */
  532.     if (myReply.sfGood) {
  533.         theFileToOpen = &myReply.sfFile;
  534.         infoRec.processInfoLength = sizeof(ProcessInfoRec);
  535.         infoRec.processName = &processName;
  536.         infoRec.processAppSpec = &procSpec;
  537.         
  538.         /* Browse for the Finder you wish to communicate with */
  539.         
  540.         if (which != kRemoteLaunchItem) {
  541.             /* if less than kRemoteLaunchItem, then we are working locally, find the finder on this machine */
  542.             
  543.             myErr = FindAProcess(kFinderType, kSysCreator, &process, &infoRec);
  544.             if (myErr == noErr)
  545.                 myErr = AECreateDesc(typeProcessSerialNumber, (Ptr)&process, sizeof(process), &myAddressDesc);
  546.             
  547.         } else {
  548.             
  549.             /* Get a remote finder  */
  550.             myErr = BrowseFerMe();
  551.         }
  552.         if (myErr == noErr) {
  553.             
  554.             /* Create the FinderEvent */
  555.             myErr = AECreateAppleEvent(kFinderType, kAEOpenSelection, &myAddressDesc, kAutoGenerateReturnID, kAnyTransactionID,
  556.                                        &aeEvent);
  557.             /* If you want to keep talking to this machine, you can keep this  */
  558.             /* address desc around */
  559.             AEDisposeDesc(&myAddressDesc);
  560.             
  561.             if (myErr == noErr) {
  562.                 /* Now we build all the bits of an OpenSelection event. */
  563.                 /* Basically, we need to create an alias for the item to open, and an alias to the parent */
  564.                 /* folder (directory) of that item. */
  565.                 /* We can also pass a list of files if we want.  */
  566.                 /* You'll notice that for opening a finder window, the file and directory alias both point at the */
  567.                 /* folder itself */
  568.                 /* make a spec for the parent folder */
  569.                 
  570.                 if (which != kRemoteLaunchItem) {
  571.                     FSMakeFSSpec(theFileToOpen->vRefNum, theFileToOpen->parID, nil, &dirSpec);
  572.                     NewAlias(nil, &dirSpec, &DirAlias);
  573.                 }
  574.                 /* Create alias for file */
  575.                 /* if you are opening a window, then you make the file alias the same as the dir alias */
  576.                 switch (which) {
  577.                     
  578.                     case kOpenAppItem:
  579.                         NewAlias(nil, theFileToOpen, &FileAlias);
  580.                         break;
  581.                         
  582.                     case kOpenWindowItem:
  583.                         NewAlias(nil, &dirSpec, &FileAlias);
  584.                         
  585.                         /* I want to set the Finder as the front process after the event  */
  586.                         /* is sent (if I can) so you can see what happened.  Rememeber, app switches */
  587.                         /* don't happen until _after_ (or during) the next WaitNextEvent call */
  588.                         
  589.                         interactErr = AEInteractWithUser(kAEDefaultTimeout, nil, (IdleProcPtr)idleProc);
  590.                         if (interactErr == noErr)
  591.                             SetFrontProcess(&process);
  592.                         break;
  593.                         
  594.                     case kRemoteLaunchItem:
  595.                         myErr = GetPathAndName(fullPath, appName);
  596.                         if (myErr == noErr) {
  597.                             /* NewAliasMinimalFromFullPath (geez what a lot of typing) creates an alias that does NOT */
  598.                             /* have a file ID, just builds based on what it has, the path.  So we don't need to */
  599.                             /* connect to another machine or file server to make this alias, which is why this thing works. */
  600.                             
  601.                             NewAliasMinimalFromFullPath(appName[0], (Ptr)&appName[1], "", "", &FileAlias);
  602.                             NewAliasMinimalFromFullPath(fullPath[0], (Ptr)&fullPath[1], "", "", &DirAlias);
  603.                         }
  604.                         break;
  605.                 }
  606.                 /* Create the file  list */
  607.                 if (myErr == noErr) {
  608.                     myErr = AECreateList(nil, 0, false, &fileList);
  609.                     
  610.                     /*  create the folder  descriptor */
  611.                     HLock((Handle)DirAlias);
  612.                     AECreateDesc(typeAlias, (Ptr)*DirAlias, GetHandleSize((Handle)DirAlias), &aeDirDesc);
  613.                     HUnlock((Handle)DirAlias);
  614.                     if ((myErr = AEPutParamDesc(&aeEvent, keyDirectObject, &aeDirDesc)) == noErr) {
  615.                         /* done with the desc, kill it */
  616.                         AEDisposeDesc(&aeDirDesc);
  617.                         /*  create the file descriptor and add to aliasList */
  618.                         HLock((Handle)FileAlias);
  619.                         AECreateDesc(typeAlias, (Ptr)*FileAlias, GetHandleSize((Handle)FileAlias), &listElem);
  620.                         HLock((Handle)FileAlias);
  621.                         myErr = AEPutDesc(&fileList, 0, &listElem);
  622.                     }
  623.                     if (myErr == noErr) {
  624.                         
  625.                         AEDisposeDesc(&listElem);
  626.                         
  627.                         /* Add the file alias list to the event */
  628.                         myErr = AEPutParamDesc(&aeEvent, aeSelectionKeyword, &fileList);
  629.                         AEDisposeDesc(&fileList);
  630.                         
  631.                         if (myErr == noErr)
  632.                             myErr = AESend(&aeEvent, &aeReply, kAENoReply + kAEAlwaysInteract + kAECanSwitchLayer,
  633.                                            kAENormalPriority, kAEDefaultTimeout, nil, nil);
  634.                     }
  635.                 }
  636.                 AEDisposeDesc(&aeEvent);
  637.             }
  638.         }
  639.     }
  640.     if ((Handle)DirAlias)
  641.         DisposHandle((Handle)DirAlias);
  642.     if ((Handle)FileAlias)
  643.         DisposHandle((Handle)FileAlias);
  644.     return(myErr);
  645. }
  646.  
  647.  
  648.  
  649. /* This runs through the process list looking for the indicated application */
  650. OSErr FindAProcess(OSType typeToFind, OSType creatorToFind, ProcessSerialNumberPtr processSN, ProcessInfoRecPtr infoRecToFill)
  651. {
  652.     ProcessSerialNumber tempPSN;
  653.     OSErr myErr = noErr;
  654.     tempPSN.lowLongOfPSN = kNoProcess;
  655.     processSN->lowLongOfPSN = kNoProcess;
  656.     processSN->highLongOfPSN = kNoProcess;
  657.     do {
  658.         myErr = GetNextProcess(processSN);
  659.         if (myErr == noErr)
  660.             GetProcessInformation(processSN, infoRecToFill);
  661.     }
  662.             while ((infoRecToFill->processSignature != creatorToFind || infoRecToFill->processType != typeToFind) ||
  663.                    myErr != noErr);
  664.     
  665.     return(myErr);
  666. }
  667.  
  668. /*  BrowseFerMe calls the PPC browser and creates an AEAddressDesc out of the Browser */
  669. /* info if the user (you) doesn't cancel */
  670.  
  671. OSErr BrowseFerMe(void)
  672. {
  673.     OSErr myErr = noErr;
  674.     Str255 tWext;
  675.     
  676.     Str255 t2Wext;
  677.     GetIndString(tWext, kGenStrings, kPPCPrompt1);
  678.     GetIndString(t2Wext, kGenStrings, kPPCPrompt2);
  679.     myErr = PPCBrowser(tWext, &t2Wext, false, &theLoc, &theRec, (PPCFilterProcPtr)FinderFilter, nil);
  680.     if (myErr == noErr) {
  681.         theID.name = theRec.name;
  682.         theID.location = theLoc;
  683.         myErr = AECreateDesc(typeTargetID, (Ptr)&theID, sizeof(theID), &myAddressDesc);
  684.     }
  685.     return(myErr);
  686. }
  687.  
  688. /* Show only FInders */
  689. pascal Boolean FinderFilter(LocationNamePtr locationName, PortInfoPtr thePortInfo)
  690. {
  691. #pragma unused (locationName)
  692.     OSType type;
  693.     
  694.     if (thePortInfo->name.portKindSelector == ppcByString) {
  695.         BlockMove(thePortInfo->name.u.portTypeStr + 1, (Ptr)&type, 4);
  696.         /* The BlockMove is so that we don't get an address error
  697.         ** on a 68000-based machine due to referencing a long at
  698.         ** an odd-address. */
  699.         if (type == kSysCreator)
  700.             return(true);
  701.     }
  702.     return(false);
  703. }
  704.  
  705. OSErr GetPathAndName(Str255 fullPath, Str255 appName)
  706. {
  707.     DialogPtr tdial = GetNewDialog(kPathDialog, nil, (WindowPtr)-1);
  708.     short hitItem = 0;
  709.     Str255 tempString;
  710.     short where;
  711.     ModalFilterProcPtr filterIt = nil;
  712.     
  713.     OSErr retVal = userCanceledErr;
  714.     SetDialogDefaultItem(tdial, ok);
  715.     SetDialogCancelItem(tdial, cancel);
  716.     SetDialogTracksCursor(tdial, true);
  717.     GetStdFilterProc(&filterIt);
  718.     ShowWindow(tdial);
  719.     DrawDialog(tdial);
  720.     do {
  721.         ModalDialog((ModalFilterProcPtr)filterIt, &hitItem);
  722.     }
  723.             while (hitItem != ok && hitItem != cancel);
  724.     if (hitItem == ok) {
  725.         GetIText((Handle)SnatchHandle(tdial, kEditLineItem), tempString);
  726.         /* now parse backwards to find the last colon, which is seperating the file name from the path */
  727.         where = tempString[0];
  728.         while (tempString[where] != kColon && where > 0)
  729.             where--;
  730.         if (where > 0) {
  731.             BlockMove((Ptr)&tempString[0], (Ptr)&appName[0], tempString[0] + 1);
  732.             BlockMove((Ptr)&tempString[0], (Ptr)&fullPath[0], where + 1);       /* include the colon */
  733.             fullPath[0] = where;
  734.             retVal = noErr;
  735.         }
  736.     }
  737.     DisposDialog(tdial);
  738.     
  739.     return(retVal);
  740. }
  741.  
  742. ControlHandle SnatchHandle(DialogPtr thebox, short theGetItem)
  743. {
  744.     short itemtype;
  745.     Rect itemrect;
  746.     Handle thandle;
  747.     
  748.     GetDItem(thebox, theGetItem, &itemtype, &thandle, &itemrect);
  749.     return((ControlHandle)thandle);
  750. }
  751.  
  752. /* end SnatchHandle */
  753.  
  754. pascal Boolean idleProc(EventRecord *eventIn, long *sleep, RgnHandle *mouseRgn)
  755. {
  756.     switch (eventIn->what) {
  757.         case nullEvent:
  758.             /* no nul processing in this sample */
  759.             *sleep = 0;
  760.             mouseRgn = nil;
  761.             break;
  762.         case updateEvt:
  763.         case activateEvt:
  764.             DrawMain((WindowPtr)eventIn->message);          /* draw whatever window needs an update */
  765.             break;
  766.         case app4Evt:
  767.             switch ((gERecord.message >> 24) & 0x0FF) {     /* high byte of message */
  768.                 case suspendResumeMessage:                  /* suspend/resume is also an activate/deactivate */
  769.                     gInBackground = (gERecord.message & kResumeMask) == 0;
  770.                     break;
  771.             }
  772.             break;
  773.             
  774.     }
  775.     return(false);                                          /* I'll wait forever */
  776. }
  777.  
  778.  
  779. #pragma segment Initialize
  780. void InitalizeApp(void)
  781. {
  782.     MenuHandle helpHandle;
  783.     StringHandle helpString;
  784.     short count;
  785.     long vers;
  786.     MaxApplZone();
  787.     InitGraf((Ptr)&qd.thePort);
  788.     InitFonts();
  789.     InitWindows();
  790.     InitMenus();
  791.     TEInit();
  792.     InitDialogs(nil);
  793.     InitCursor();
  794.     /* Check system version */
  795.     Gestalt(gestaltSystemVersion, &vers);
  796.     vers = (vers >> 8) & 0xf;                               /* shift result over and mask out major version number */
  797.     if (vers < 7) {
  798.         StopAlert(kBadSystem, nil);
  799.         ExitToShell();
  800.     }
  801.     InitAEStuff();
  802.     /* set up my menu junk */
  803.     gMymenu = GetNewMBar(kMBarID);
  804.     SetMenuBar(gMymenu);
  805.     gAppleMenuHandle = GetMHandle(kAppleMenu);
  806.     gFileMenuHandle = GetMHandle(kFileMenu);
  807.     gEditMenuHandle = GetMHandle(kEditMenu);
  808.     gToolMenuHandle = GetMHandle(kToolsMenu);
  809.     AddResMenu(gAppleMenuHandle, 'DRVR');
  810.     /* now install my Help menu item in the Help Manager's menu */
  811.     HMGetHelpMenuHandle(&helpHandle);                       /* Get the Hlpe menu handle */
  812.     count = CountMItems(helpHandle);                        /* How many items are there? */
  813.     helpString = GetString(kHelpString);                    /* get my help string */
  814.     DetachResource(helpString);                             /* detach it */
  815.     HNoPurge(helpString);
  816.     MoveHHi((Handle)helpString);
  817.     HLock((Handle)helpString);
  818.     InsMenuItem(helpHandle, (Ptr)*helpString, count + 1);       /* insert my item in the Help menu */
  819.     gHelpItem = CountMItems(helpHandle);                    /* The number of the item */
  820.     
  821.     DrawMenuBar();
  822.     GetCurrentProcess(&gOurSN);                             /* Get our process serial number for later use, if needed */
  823. }
  824.